{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.7024880213886435\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "欧式香草期权的PDE定价\n",
    "模型: BS + flat vol\n",
    "定价方法: PDE\n",
    "\"\"\"\n",
    "\n",
    "import numpy as np\n",
    "import scipy.sparse as sp\n",
    "import scipy.interpolate as spi\n",
    "import scipy.linalg as sla\n",
    "\n",
    "TYPE_TO_SIGN = {'call': 1, 'put': -1}\n",
    "\n",
    "\n",
    "class VanillaPDE():\n",
    "    def __init__(self, r, q, vol, T, s0=100, strike=105, type=\"call\"):  # method : \"exp\"/\"imp\"/\"CN\"\n",
    "        self.s0 = s0  # 期初价格\n",
    "        self.strike = strike  # 执行价\n",
    "        self.T = T  # 到期时间(年)\n",
    "        self.r = r  # 无风险利率\n",
    "        self.q = q  # 分红/融券率\n",
    "        self.vol = vol  # 波动率\n",
    "        self.type = type  # 看涨看跌: call/put\n",
    "        self.set_method_params()\n",
    "\n",
    "\n",
    "    def set_method_params(self, params=None):\n",
    "        \"\"\"设置方法参数，选填，有默认值\n",
    "        \"\"\"\n",
    "        if not isinstance(params, dict):\n",
    "            return\n",
    "        # 年化系数，默认值244日/年\n",
    "        self.ndays = params['ndays'] if 'ndays' in params.keys() else 244\n",
    "        # 时间步数，默认为年化系数 x 期权到期年数\n",
    "        self.t_step = params['t_step'] if 't_step' in params.keys() else int(self.T * self.ndays)\n",
    "        # 价格步数\n",
    "        self.s_step = params['s_step'] if 's_step' in params.keys() else 400\n",
    "        # PDE定价参数：最小标的价格\n",
    "        self.Smin = params['Smin'] if 'Smin' in params.keys() else 0\n",
    "        # PDE定价参数：最大标的价格\n",
    "        self.Smax = params['Smax'] if 'Smax' in params.keys() else self.s0 * 4\n",
    "        # PDE定价数值方法：显式exp/隐式imp/半隐式CN(Crank-Nicolson)\n",
    "        self.method = params['method'] if 'method' in params.keys() else 'CN'\n",
    "\n",
    "    def _load_params(self):\n",
    "        self.sign = TYPE_TO_SIGN[self.type]\n",
    "        self.dS = (self.Smax - self.Smin) / self.s_step\n",
    "        self.dt = self.T / self.t_step\n",
    "        self.S_vec = np.linspace(self.Smin, self.Smax, self.s_step + 1)\n",
    "        self.T_vec = np.linspace(0, self.T, self.t_step + 1)\n",
    "        self.i_vec = np.linspace(0, self.s_step, self.s_step + 1)\n",
    "        self.grid = np.zeros(shape=(self.s_step + 1, self.t_step + 1))\n",
    "        if self.method == 'CN':\n",
    "            self.theta = 0.5\n",
    "        elif self.method == 'imp':\n",
    "            self.theta = 1\n",
    "        elif self.method == \"exp\":\n",
    "            if self.dt >= 1 / (self.vol * self.s_step) ** 2:\n",
    "                print(f\"Warning: dt >= 1/(vol * s_step)^2, 显式求解过程不稳定, 请增大t_step\")\n",
    "            self.theta = 0\n",
    "        else:\n",
    "            raise Exception(f\"{self.method}不是exp(显式),imp(隐式)或CN(半隐式)方法, 请检查.\")\n",
    "\n",
    "    def _set_terminal_condition_(self):\n",
    "        \"\"\"终止条件\"\"\"\n",
    "        self.grid[:, -1] = np.maximum(self.sign * (self.S_vec - self.strike), 0)\n",
    "\n",
    "    def _set_boundary_condition_(self):\n",
    "        \"\"\"边界条件\"\"\"\n",
    "        tau = self.T_vec[-1] - self.T_vec[:-1]\n",
    "        if self.sign == 1:  # call\n",
    "            self.grid[0, :] = 0\n",
    "            self.grid[-1, :-1] = self.Smax * np.exp(-self.q * tau) - self.strike * \\\n",
    "                                 np.exp(-self.r * tau)\n",
    "        else:  # put\n",
    "            self.grid[0, :-1] = self.strike * np.exp(-self.r * self.tau)\n",
    "            self.grid[-1, :] = 0\n",
    "\n",
    "    def _solve_exp_(self):\n",
    "        \"\"\"显式求解\"\"\"\n",
    "        # 递推系数：上一时间的相邻三项，经典PDE定义\n",
    "        a = 0.5 * self.dt * (self.vol ** 2 * self.i_vec - (self.r - self.q)) * self.i_vec\n",
    "        b = 1 - self.dt * (self.vol ** 2 * self.i_vec ** 2 + self.r)\n",
    "        c = 0.5 * self.dt * (self.vol ** 2 * self.i_vec + (self.r - self.q)) * self.i_vec\n",
    "        # 迭代递推，t_step为时间步数，从倒数第二天向第一天反向递推\n",
    "        for j in reversed(np.arange(self.t_step)):\n",
    "            # s_step为价格步数，计算除了最小Smin和最大Smax的其他所有的价格格点\n",
    "            for i in range(1, self.s_step, 1):\n",
    "                self.grid[i, j] = a[i] * self.grid[i - 1, j + 1] + b[i] * self.grid[i, j + 1] + c[i] * self.grid[\n",
    "                    i + 1, j + 1]\n",
    "\n",
    "    def _set_coefficient_(self):\n",
    "        \"\"\"系数矩阵预计算, l、d、u分别是对角线下方lower、主对角线diagonal和对角线上方upper的系数数组\"\"\"\n",
    "        # self.i_vec[1:-1] == self.S_vec[1:-1] / self.dS\n",
    "        drift = (self.r - self.q) * self.i_vec[1:-1]\n",
    "        diffusion_square = (self.vol * self.i_vec[1:-1]) ** 2\n",
    "        # 这里是以半隐式的系数写的，之后在_set_matrix_矩阵里整体乘以dt，再乘以theta=1/2\n",
    "        self.l = 0.5 * (diffusion_square - drift)\n",
    "        self.d = -diffusion_square - self.r\n",
    "        self.u = 0.5 * (diffusion_square + drift)\n",
    "\n",
    "    def _set_matrix_(self):\n",
    "        \"\"\"生成系数矩阵\"\"\"\n",
    "        # 创建三对角矩阵A，用来构造半隐式矩阵M1，M2\n",
    "        self.A = sp.diags([self.l[1:], self.d, self.u[:-1]], [-1, 0, 1], format='csc') * self.dt\n",
    "        # 单位矩阵I\n",
    "        self.I = sp.eye(self.s_step - 1)\n",
    "        # j 时点的期权价值向量（未知量）的系数矩阵。\n",
    "        self.M1 = self.I - self.theta * self.A\n",
    "        # j + 1 时点的期权价值向量（已知量）的系数矩阵（对于隐式imp，M2是单位阵）\n",
    "        self.M2 = self.I + (1 - self.theta) * self.A\n",
    "\n",
    "\n",
    "    def _solve_imp_or_CN_(self):\n",
    "        \"\"\"隐式或半隐式求解: self.theta = 1 就是隐式方法, self.theta = 0.5 就是半隐式方法\"\"\"\n",
    "        for j in reversed(np.arange(self.t_step)):\n",
    "            # V = 矩阵方程右侧，系数M2乘以j + 1 时点的期权价值向量（已知量）\n",
    "            V = self.M2.dot(self.grid[1:-1, j + 1])\n",
    "            # 最上和最下两个方程额外多一项\n",
    "            V[0] += self.theta * self.l[0] * self.dt * self.grid[0, j] \\\n",
    "                    + (1 - self.theta) * self.l[0] * self.dt * self.grid[0, j + 1]\n",
    "            V[-1] += self.theta * self.u[-1] * self.dt * self.grid[-1, j] \\\n",
    "                     + (1 - self.theta) * self.u[-1] * self.dt * self.grid[-1, j + 1]\n",
    "            # 求解\n",
    "            self.grid[1:-1, j] = TDMA(self.M1, V)\n",
    "\n",
    "    def _interpolate_(self):\n",
    "        tck = spi.splrep(self.S_vec, self.grid[:, 0], k=3)\n",
    "        return spi.splev(self.s0, tck)\n",
    "\n",
    "    def pricing(self):\n",
    "        self._load_params()\n",
    "        self._set_terminal_condition_()\n",
    "        self._set_boundary_condition_()\n",
    "        if self.method == \"exp\":\n",
    "            self._solve_exp_()\n",
    "        elif self.method in [\"imp\", \"CN\"]:\n",
    "            self._set_coefficient_()\n",
    "            self._set_matrix_()\n",
    "            self._solve_imp_or_CN_()\n",
    "        else:\n",
    "            raise Exception(f\"{self.method}不是exp(显式),imp(隐式)或CN(半隐式)方法, 请检查.\")\n",
    "        return self._interpolate_()\n",
    "\n",
    "def TDMA(X, d):\n",
    "    n = len(d)\n",
    "    a = np.array(X[np.arange(n - 1) + 1, np.arange(n - 1)])[0]\n",
    "    b = np.array(X[np.arange(n), np.arange(n)])[0]\n",
    "    c = np.array(X[np.arange(n - 1), np.arange(n - 1) + 1])[0]\n",
    "    w = np.zeros(n - 1, float)\n",
    "    g = np.zeros(n, float)\n",
    "    p = np.zeros(n, float)\n",
    "\n",
    "    w[0] = c[0] / b[0]\n",
    "    g[0] = d[0] / b[0]\n",
    "\n",
    "    for i in range(1, n - 1):\n",
    "        w[i] = c[i] / (b[i] - a[i - 1] * w[i - 1])\n",
    "    for i in range(1, n):\n",
    "        g[i] = (d[i] - a[i - 1] * g[i - 1]) / (b[i] - a[i - 1] * w[i - 1])\n",
    "    p[n - 1] = g[n - 1]\n",
    "    for i in range(n - 1, 0, -1):\n",
    "        p[i - 1] = g[i - 1] - w[i - 1] * p[i]\n",
    "    return p.reshape(n, )\n",
    "\n",
    "\n",
    "def adjust_method_params(model, method):\n",
    "    # 定价方法参数\n",
    "    if method == \"exp\":  # 显式为了求解稳定，t_step需要设的很大\n",
    "        method_params = {'s_step': 200, 't_step': 5000, 'method': method}\n",
    "    else:\n",
    "        method_params = {'s_step': 400, 't_step': int(model.T * 244), 'method': method}\n",
    "    # 设置方法参数\n",
    "    model.set_method_params(method_params)\n",
    "    return vanilla_pde\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    method = \"CN\"  # \"exp\",\"imp\",\"CN\"\n",
    "    # 定价模型实例\n",
    "    vanilla_pde = VanillaPDE(r=0.02, q=0.0, vol=0.2, T=1, s0=100, strike=105, type='call')\n",
    "    adjust_method_params(vanilla_pde, method)\n",
    "    # 定价\n",
    "    print(vanilla_pde.pricing())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.704774819436658\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy.stats import norm\n",
    "\n",
    "class BSMmodel:         \n",
    "    \"\"\"欧式股票期权BSM公式\"\"\"\n",
    "    def __init__(self, S, K, T, r, vol, sign=1, q=0):\n",
    "        \"\"\"认购期权的sign为1, 认沽期权的sign为-1。若股票有稳定的连续分红率q, 请传入参数q。\n",
    "        \"\"\"\n",
    "        self.S, self.K, self.T, self.r, self.vol, self.sign, self.q = S, K, T, r, vol, sign, q\n",
    "\n",
    "    def bsm_d(self):\n",
    "        d1 = (np.log(self.S / self.K) + (self.r - self.q + 0.5 * self.vol ** 2) * self.T) / (\n",
    "                self.vol * np.sqrt(self.T))\n",
    "        d2 = d1 - self.vol * np.sqrt(self.T)\n",
    "        return d1, d2\n",
    "\n",
    "    @property\n",
    "    def option_price(self):\n",
    "        self.d1, self.d2 = self.bsm_d()\n",
    "        return self.sign * np.exp(-self.q * self.T) * self.S * norm.cdf(self.sign * self.d1) - self.sign * np.exp(\n",
    "            -self.r * self.T) * self.K * norm.cdf(self.sign * self.d2)\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    vanilla_analytic = BSMmodel(S=100, K=105, T=1, r=0.02,vol=0.2, sign=1, q=0)\n",
    "    print(vanilla_analytic.option_price)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done\n"
     ]
    }
   ],
   "source": [
    "price_arr = np.arange(80, 120, 5)\n",
    "res = {\"analytic\":[], \"exp\":[], \"imp\":[], \"CN\":[]}\n",
    "\n",
    "for price in price_arr:\n",
    "    vanilla_analytic = BSMmodel(S=price, K=100, T=1, r=0.02,vol=0.2, q=0.01, sign=1)\n",
    "    res[\"analytic\"].append(vanilla_analytic.option_price)\n",
    "    vanilla_pde = VanillaPDE(s0=price, strike=100, T=1, r=0.02, vol=0.2, q=0.01, type='call')\n",
    "    adjust_method_params(vanilla_pde, \"exp\")\n",
    "    res[\"exp\"].append(vanilla_pde.pricing())\n",
    "    adjust_method_params(vanilla_pde, \"imp\")\n",
    "    res[\"imp\"].append(vanilla_pde.pricing())\n",
    "    adjust_method_params(vanilla_pde, \"CN\")\n",
    "    res[\"CN\"].append(vanilla_pde.pricing())\n",
    "\n",
    "print(\"Done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams[\"font.sans-serif\"] = [\"SimHei\"]  # 设置中文显示\n",
    "plt.rcParams[\"axes.unicode_minus\"] = False  # 解决负号显示为方块的问题\n",
    "fig, ax = plt.subplots()\n",
    "marker_size = 100\n",
    "ax.scatter(price_arr, res[\"analytic\"], edgecolors=\"#1f77b4\", c='none', marker='o', s=marker_size, label=\"BS公式\")\n",
    "ax.scatter(price_arr, res[\"exp\"], color=\"#ff7f0e\", marker=\"x\", s=marker_size, label=\"显式exp\")\n",
    "ax.scatter(price_arr, res[\"imp\"], color=\"#2ca02c\", marker=\"+\", s=marker_size, label=\"隐式imp\")\n",
    "ax.scatter(price_arr, res[\"CN\"], edgecolors=\"#d62728\", c='none', marker=\".\", s=marker_size, label=\"半隐式CN\")\n",
    "ax.set_title('PDE与BS公式定价对比')\n",
    "ax.set_xlabel('标的价格')\n",
    "ax.set_ylabel('期权价格')\n",
    "ax.set_facecolor('#e9e7ef')\n",
    "ax.legend()\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
